package com.bitoon.basketdudes.web.xhr;

import com.bitoon.basketdudes.web.BaseAction;
import com.bitoon.basketdudes.web.jpa.Torneo;
import com.bitoon.basketdudes.web.datos.InfoCabeceraXHR;
import com.bitoon.basketdudes.web.datos.MensajeUsuario;
import com.bitoon.basketdudes.web.jpa.Equipo;
import com.bitoon.basketdudes.web.jpa.Participe;
import com.bitoon.basketdudes.web.jpa.ParticipePK;
import com.bitoon.basketdudes.web.jpa.Temporada;
import com.bitoon.basketdudes.web.jpa.Usuario;

import java.util.*;
import javax.persistence.*;
import org.apache.log4j.Logger;

public class ListaTorneosUsuario extends BaseAction {

    public static final String MAX_APUNTADOS = "max_apuntados";
    private static int MAX_TORNEOS_APUNTADOS = 6;
    private static int MAX_TORNEOS_PARTICIPANDO = 2;

    private List<Torneo> datos;
    private List<Torneo> torneosSugeridos;
    private List<Torneo> torneosPropios;
    private List<Participe> torneosUsuario;
    private List<Equipo> listaEquiposManager;
    private InfoCabeceraXHR cabecera;
    private int pagina = 1;
    private int cuantos;
    private int mostrarPropios = 0;

    // Parámetros de búsqueda por letras y torneoUrl
    private String letras;

    // Parámetros del filtrado
    private String modificador_historico;
    private String modificador_media;
    private String modificador_nivel;
    private String modificador_posicion;
    private String numero_historico;
    private String numero_media;
    private String numero_nivel;
    private String numero_posicion;

    // XHR de apuntarse
    private String contrasena;
    private String equipo;
    private String nombre;

    // Parámetros de búsqueda de cadena
    private String cadena;

    private Logger log = Logger.getLogger(ListaTorneosUsuario.class);

    public String execute() {

        try {
            String letraDesde = "a";
            String letraHasta = "c";

            log.debug(">>>>>>>>>>>>>>>>>> letrassss: " + letras);

            if (modificador_historico != null) {
                // Filtrado
                buscarTorneos("0", "9");
            } else if (cadena != null) {
                // Búsqueda por cadena
                log.debug("Buscar torneos cadena: " + cadena);
                buscarTorneosCadena(cadena);
            } else {
                // Acceso por defecto, navegación
                if (letras != null) {
                    if (letras.length() == 3) {
                        letraDesde = letras.substring(0,1);
                        letraHasta = letras.substring(2,3);
                    } else if (letras.equals("todos")) {
                        letraDesde = "0";
                        letraHasta = "9";
                    } else if (letras.equals("propios")) {
                        if (getUsuarioLogado() == null) {
                            letraDesde = "a";
                            letraHasta = "c";
                        } else {
                            letras = null;
                            mostrarPropios = 1;
                        }
                    }
                }
                log.debug("Buscando torneos desde " + letraDesde + " hasta " + letraHasta);
                buscarTorneos(letraDesde, letraHasta);
            }

            // Buscar los torneos en los que el usuario está apuntado
            Usuario u = getUsuarioLogado();
            if (u!=null) {
                buscarTorneosApuntado(u.getId());
                setListaEquiposManager(u.getEquipos());
                buscarTorneosSugeridos();
                buscarTorneosPropios();
            }
        } catch (Exception e) {
            log.error("Error", e);
        }

        return SUCCESS;
    }

    public String apuntarse() {

        String retorno = SUCCESS;

        cabecera = new InfoCabeceraXHR();
        cabecera.setCorrecto(0);

        log.debug("apuntar al equipo " + equipo + " en el torneo " + nombre + " con contrasena " + contrasena);

        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager(); // checked
            Equipo equipoParticipa = null;
            Temporada temporada = null;

            Query q = em.createNamedQuery("Equipo.findByNombreUrl");
            q.setParameter("nombre", equipo);
            equipoParticipa = (Equipo)q.getSingleResult();

            log.debug("equipoParticipa: " + equipoParticipa);

            // Ver si el que intenta apuntarse está logado y es el dueño del equipo

            if (equipoParticipa.getUsuario().getId().equals(getUsuarioLogado().getId())) {

                // Ver en cuántos torneos está apuntado
                log.debug("buscando apuntados de: " + equipoParticipa.getUsuario().getId());
                q = em.createNamedQuery("Participe.torneosApuntado");
                q.setParameter("idUsuario", equipoParticipa.getUsuario().getId());
                List<Participe> apuntados = (List<Participe>)q.getResultList();

                log.debug("apuntados.size: " + apuntados.size());

                if (apuntados.size()>=MAX_TORNEOS_APUNTADOS) {
                    retorno = MAX_APUNTADOS;
                    cabecera.setCorrecto(1);
                    cabecera.setLimiteTorneos(1);
                    setMensajeAlerta(getText("alertas.torneos_de_usuario.apuntarse.limite"));
                } else {
                    q = em.createNamedQuery("Temporada.findTemporadaActivaByTorneoUrl");
                    q.setParameter("nombre", nombre);
                    temporada = (Temporada)q.getSingleResult();

                    log.debug("temporada: " + temporada);

                    boolean puedeApuntarse = false;

                    log.debug(">>> 1");

                    if (temporada.getPrivada() == 1) { // Privada
                        if (temporada.getPassword()!=null
                                && temporada.getPassword().equalsIgnoreCase(contrasena)) {
                            puedeApuntarse = true;
                        }
                    } else {
                        puedeApuntarse = true;
                    }

                    // Comprobar que el usuario del equipo no es partícipe del torneo

                    q = em.createNamedQuery("Participe.findByUsuarioIdTemporadaId");
                    log.debug("idUsurio: " + equipoParticipa.getUsuario().getId());
                    log.debug("itEmporada: " + temporada.getId());
                    q.setParameter("idUsuario", equipoParticipa.getUsuario().getId());
                    q.setParameter("idTemporada", temporada.getId());
                    List<Participe> yaEstaParticipando = (List<Participe>)q.getResultList();

                    log.debug("yaEstaParticipando: " + yaEstaParticipando);

                    if (yaEstaParticipando.size()>0) {
                        puedeApuntarse = false;
                    }

                    log.debug("puedeApuntarse: " + puedeApuntarse);

                    if (puedeApuntarse) {

                        cabecera.setCorrecto(apuntarse(temporada, equipoParticipa,
                                contrasena, log, em));

                        if (cabecera.getCorrecto()==1) {
                            // Todo ha ido bien
                            setMensajeAlerta(getText("alertas.torneos_de_usuario.apuntarse.apuntado"));

                            // Enviar mensaje interno al administrador del torneo

                            // Buscar el organizador del torneo
                            q = em.createNamedQuery("Torneo.findByNombreUrl");
                            q.setParameter("nombreUrl", nombre);
                            List<Torneo> torneo = (List<Torneo>)q.getResultList();

                            Torneo elTorneo = (Torneo)torneo.get(0);
                            int idOrganizador = elTorneo.getUsuario().getId();

                            log.debug(">>>> mandar mensaje a " + idOrganizador);

                            MensajeUsuario mens = new MensajeUsuario();
                            mens.setFrom("BasketDudes");
                            mens.setSender(0);
                            mens.setTo(elTorneo.getUsuario().getNickMostrar());
                            mens.setReceiver(idOrganizador);
                            mens.setTipoDestinatario(MensajeUsuario.TIPO_USUARIO_NORMAL);
                            mens.setTipoUsuarioEmisor(MensajeUsuario.TIPO_USUARIO_ADMINISTRADOR_WEB);

                            mens.setAsunto(getText("mensaje_interno.torneos_de_usuario.inscripcion.titulo."+elTorneo.getUsuario().getIdioma().toLowerCase()));
                            List<Object> params = new ArrayList<Object>();
                            params.add(getUsuarioLogado().getNickMostrar());
                            params.add(elTorneo.getNombre());
                            params.add(elTorneo.getNombreUrl());
                            mens.setTexto(getText("mensaje_interno.torneos_de_usuario.inscripcion.mensaje."+elTorneo.getUsuario().getIdioma().toLowerCase(),params));

                            escribirMensaje(mens);
                        } else if (cabecera.getCorrecto()==-2) {
                            setMensajeAlerta(getText("alertas.torneos_de_usuario.apuntarse.sin_nivel"));
                        } else {
                            setMensajeAlerta(getText("alertas.torneos_de_usuario.apuntarse.error"));
                        }
                    } else {
                        setMensajeAlerta(getText("alertas.torneos_de_usuario.apuntarse.error"));
                    }
                }
            }
        } catch (NoResultException nre) {
            log.debug("No se ha encontrado el equipo o la temporada");
        } catch (Exception e) {
            log.error("Algo ha pasado", e);
        } finally {
            try { if (em.getTransaction().isActive()) { em.getTransaction().rollback(); }; } catch (Exception e) { }
            try { em.close(); } catch (Exception e) { log.error("Error: ", e); }
        }
        
        return retorno;
    }

    public static int apuntarse(Temporada temporada, Equipo equipoParticipa,
            String contrasena, Logger log, EntityManager em) {

        int retorno = 0;

        boolean puedeApuntarse = false;

        log.debug(">>> 1");

        if (temporada.getPrivada() == 1) { // Privada
            if (temporada.getPassword()!=null
                    && temporada.getPassword().equalsIgnoreCase(contrasena)) {
                puedeApuntarse = true;
            }
        } else {
            puedeApuntarse = true;
        }

        log.debug("puedeApuntarse: " + puedeApuntarse);

        // Ver si cumple requisitos de nivel

        log.debug("nivel " + equipoParticipa.getNivel() + " entre " + temporada.getNivelIni() + " y " + temporada.getNivelFin());

        if (equipoParticipa.getNivel() < temporada.getNivelIni() || equipoParticipa.getNivel() > temporada.getNivelFin()) {
            puedeApuntarse = false;
            retorno = -2;
        } else {
            if (puedeApuntarse) {
                Participe p = new Participe();
                ParticipePK ppk = new ParticipePK();

                /*
                p.setEquipo(equipoParticipa);
                p.setTemporada(temporada);
                 *
                 */

                ppk.setEquipoId(equipoParticipa.getId());
                ppk.setTemporadaId(temporada.getId());

                p.setParticipePK(ppk);

                p.setTemporada(temporada);
                p.setFavor(0);
                p.setContra(0);

                p.setGanados((short)0);
                p.setPerdidos((short)0);
                p.setEstado((short)0);
                p.setPuntos(0);

                log.debug("hasta aquí ...");

                em.getTransaction().begin();
                em.persist(p);
                em.getTransaction().commit();

                //cabecera.setCorrecto(1);

                retorno = 1;

                log.debug("finalizado!");
            } else {
                retorno = -1;
            }
        }

        return retorno;

    }

    private void buscarTorneos() {
        buscarTorneos("a","c");
    }

    public Temporada getTemporadaActiva(int idTorneo) {
        EntityManager em = null;
        Temporada retorno = null;

        try {
            em = emfBasket.createEntityManager(); // checked
            Temporada temporada = null;

            log.debug("Buscando temporada activa ..." + idTorneo);

            Query q = em.createNamedQuery("Temporada.findTemporadaActivaByTorneoId");
            q.setParameter("id", idTorneo);
            q.setMaxResults(1);
            retorno = (Temporada)q.getSingleResult();
            log.debug("temp. activa: " + retorno);
        } catch (NoResultException nre) {
        } catch (Exception e) {
            log.error("Error en getTemporadaActiva: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return retorno;
    }

    private void buscarTorneos(String letraDesde, String letraHasta) {
        List<Torneo> retorno = null;
        EntityManager em = null;

        try {
            retorno = new ArrayList<Torneo>();

            em = emfBasket.createEntityManager(); // checked

            log.debug(">>> Buscando: " + letras);

            // Hacer que la letraHasta sea la siguiente a la pasada. Si es c, que sea d; si es o, que sea p; etc.

            if (letras!=null && !letras.equals("todos")) {
                char l = letraHasta.charAt(0);
                if (l!='9') {
                    int c = (int)l;
                    l = (char)(l+1);
                    letraHasta = "" + l;
                }
            }

            int numPropios = 0;

            if (letras==null && getUsuarioLogado()!=null) {
                // Buscar los torneos propios del usuario

                // Se han indicado qué letras hay que buscar

                int totalRegistros = 5;
                int totalPaginas = 1;

                Query q = em.createNamedQuery("Torneo.findByUsuarioId");
                q.setParameter("idUsuario", getUsuarioLogado().getId());
                q.setMaxResults(totalRegistros);
                retorno = (List<Torneo>)q.getResultList();

                numPropios = retorno.size();

                //Hibernate.initialize(retorno);

                cabecera = new InfoCabeceraXHR();
                cabecera.setCorrecto(1);
                cabecera.setActual(pagina);
                cabecera.setTotal(totalPaginas);

                int p1=1, p2=1;

                cabecera.setPrimeraPagina(p1);
                cabecera.setUltimaPagina(p2);

                setDatos(retorno);
                setCabecera(cabecera);
            }

            if (numPropios == 0 || letras!=null || getUsuarioLogado()==null) {
                // Se han indicado qué letras hay que buscar o no está logado o no tiene propios

                //letras = "a-c";
                
                Query qc = em.createNamedQuery("Torneo.findByFirstLetters");

                log.debug("Dentro de buscar ... " + letraDesde + "," + letraHasta);

                qc.setParameter("letraDesde", letraDesde);
                qc.setParameter("letraHasta", letraHasta);

                int totalRegistros = qc.getResultList().size();
                log.debug("totalRegistros: " + totalRegistros);
                int totalPaginas = (totalRegistros-1)/LISTADO_TORNEOS_ELEMENTOS_POR_PAGINA + 1;

                int offset = (pagina-1) * LISTADO_TORNEOS_ELEMENTOS_POR_PAGINA;

                Query q = em.createNamedQuery("Torneo.findByFirstLetters");
                q.setParameter("letraDesde", letraDesde);
                q.setParameter("letraHasta", letraHasta);
                q.setFirstResult((pagina-1)*LISTADO_TORNEOS_ELEMENTOS_POR_PAGINA);
                q.setFirstResult(offset);
                q.setMaxResults(LISTADO_TORNEOS_ELEMENTOS_POR_PAGINA);

                retorno = (List<Torneo>)q.getResultList();

                //Hibernate.initialize(retorno);

                cabecera = new InfoCabeceraXHR();
                cabecera.setCorrecto(1);
                cabecera.setActual(pagina);
                cabecera.setTotal(totalPaginas);

                int p1=0, p2=0;

                if (pagina <= (LISTADO_TORNEOS_HUECOS_LADO_PAGINA+1)) {
                    p1 = 1;
                    p2 = LISTADO_TORNEOS_HUECOS_LADO_PAGINA*2 + 1;
                } else if (pagina >= (totalPaginas-LISTADO_TORNEOS_HUECOS_LADO_PAGINA)) {
                    p1 = totalPaginas - (LISTADO_TORNEOS_HUECOS_LADO_PAGINA*2);
                    p2 = totalPaginas;
                } else {
                    p1 = pagina - LISTADO_TORNEOS_HUECOS_LADO_PAGINA;
                    p2 = pagina + LISTADO_TORNEOS_HUECOS_LADO_PAGINA;
                }
                if (p1 < 1) {
                    p1 = 1;
                }
                if (p2 > totalPaginas) {
                    p2 = totalPaginas;
                }
                cabecera.setPrimeraPagina(p1);
                cabecera.setUltimaPagina(p2);

                setDatos(retorno);
                setCabecera(cabecera);
            } else {

            }

        } catch (Exception e) {
            log.error("[buscaTorneos]: Error: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

    }



    private void buscarTorneosCadena(String cadena) {
        List<Torneo> retorno = null;
        EntityManager em = null;

        try {
            retorno = new ArrayList<Torneo>();

            em = emfBasket.createEntityManager(); // checked

            // Se han indicado qué letras hay que buscar o no está logado o no tiene propios

            //letras = "a-c";

            log.debug("martesssss: 1");

            Query qc = em.createNativeQuery("select * from basket.torneo where lower(nombre) like '%" + cadena + "%' order by nombre", Torneo.class);
            int totalRegistros = 0;
            if (qc.getResultList()!=null) {
                totalRegistros = qc.getResultList().size();
            }
            int totalPaginas = (totalRegistros-1)/LISTADO_TORNEOS_ELEMENTOS_POR_PAGINA + 1;

            int offset = (pagina-1) * LISTADO_TORNEOS_ELEMENTOS_POR_PAGINA;

            log.debug("martesssss: 2");

            Query q = em.createNativeQuery("select * from basket.torneo where lower(nombre) like '%" + cadena + "%' order by nombre", Torneo.class);
            q.setFirstResult((pagina-1)*LISTADO_TORNEOS_ELEMENTOS_POR_PAGINA);
            q.setFirstResult(offset);
            q.setMaxResults(LISTADO_TORNEOS_ELEMENTOS_POR_PAGINA);

            retorno = (List<Torneo>)q.getResultList();

            //Hibernate.initialize(retorno);

            log.debug("martesssss: " + pagina);
            log.debug("martesssss: " + totalPaginas);

            cabecera = new InfoCabeceraXHR();
            cabecera.setCorrecto(1);
            cabecera.setActual(pagina);
            cabecera.setTotal(totalPaginas);

            int p1=0, p2=0;

            if (pagina <= (LISTADO_TORNEOS_HUECOS_LADO_PAGINA+1)) {
                p1 = 1;
                p2 = LISTADO_TORNEOS_HUECOS_LADO_PAGINA*2 + 1;
            } else if (pagina >= (totalPaginas-LISTADO_TORNEOS_HUECOS_LADO_PAGINA)) {
                p1 = totalPaginas - (LISTADO_TORNEOS_HUECOS_LADO_PAGINA*2);
                p2 = totalPaginas;
            } else {
                p1 = pagina - LISTADO_TORNEOS_HUECOS_LADO_PAGINA;
                p2 = pagina + LISTADO_TORNEOS_HUECOS_LADO_PAGINA;
            }
            if (p1 < 1) {
                p1 = 1;
            }
            if (p2 > totalPaginas) {
                p2 = totalPaginas;
            }
            cabecera.setPrimeraPagina(p1);
            cabecera.setUltimaPagina(p2);

            setDatos(retorno);
            setCabecera(cabecera);

            log.debug("martesssss: 3");

        } catch (Exception e) {
            log.error("[buscaTorneosCadena]: Error: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

    }


    private void buscarTorneosPropios() {
        EntityManager em = null;

        try {

            em = emfBasket.createEntityManager(); // checked

            // Buscar los torneos sugeridos al usuario logado

            log.debug("Buscando propios ...");
            Query q = em.createNamedQuery("Torneo.findByUsuarioId");
            q.setParameter("idUsuario", getUsuarioLogado().getId());
            torneosPropios = (List<Torneo>)q.getResultList();
            log.debug("Torneos Propios: " + torneosPropios);

        } catch (Exception e) {
            log.error("[buscarTorneosPropios]: Error: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

    }



    private void buscarTorneosSugeridos() {
        EntityManager em = null;

        try {

            em = emfBasket.createEntityManager(); // checked

            // Buscar los torneos sugeridos al usuario logado

            int totalRegistros = 15; // Ponemos 15 para poder "extraer" 5 al usuario

            log.debug("Buscando sugeridos ...");
            Query q = em.createNamedQuery("Torneo.findSugeridos");
            q.setMaxResults(totalRegistros);
            torneosSugeridos = (List<Torneo>)q.getResultList();
            log.debug("Buscando sugeridos ... " + torneosSugeridos);

        } catch (Exception e) {
            log.error("[buscarTorneosSugeridos]: Error: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

    }


    public List<Participe> buscarTorneosEquipo(int idEquipo) {
        List<Participe> retorno = null;
        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager(); // checked

            Query q = em.createNamedQuery("Participe.findByEquipoId");
            q.setParameter("idEquipo", idEquipo);
            log.info("size ... " + q.getResultList().size());
            if (q.getResultList().size() > 0) {
                retorno = new ArrayList<Participe>();
                retorno = (List<Participe>)q.getResultList();
            }
        } catch (Exception e) {
            log.error("[buscaTorneos]: Error: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return retorno;
    }
    

    private void buscarTorneosApuntado(int idUsuario) {
        List<Participe> retorno = null;
        EntityManager em = null;

        try {
            retorno = new ArrayList<Participe>();

            em = emfBasket.createEntityManager(); // checked

            Query q = em.createNamedQuery("Participe.findByUsuarioId");
            q.setParameter("idUsuario", idUsuario);
            retorno = (List<Participe>)q.getResultList();

            setTorneosUsuario(retorno);

        } catch (Exception e) {
            log.error("[buscaTorneos]: Error: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

    }


    public int getEstadoTorneo(int idTemporada) {
        
        /*
         * Devuelve el estado de un torneo de usuario:
         * 
         *  0: libre para apuntarse y no comenzada
         *  1: completa y no comenzada
         *  2: comenzada
         *  3: no apto / error
         */

        int TEMPORADA_LIBRE = 0;
        int TEMPORADA_COMPLETA = 1;
        int TEMPORADA_COMENZADA = 2;
        int TEMPORADA_NO_APTO = 3;
        int TEMPORADA_INSCRITO = 4; // El administrador ha admitido al equipo
        int TEMPORADA_PARTICIPANDO = 5;
        int TEMPORADA_PENDIENTE = 6; // El administrador no ha admitido aún al equipo

        int retorno = TEMPORADA_LIBRE;

        boolean apto = false;
        boolean apuntado = false;
        boolean pendiente = false;

        EntityManager em = null;

        Usuario usuario = null;
        List<Equipo> equipos = null;

        try {
            em = emfBasket.createEntityManager(); // checked
            Temporada t = em.find(Temporada.class, idTemporada);
            usuario = getUsuarioLogado();
            if (usuario != null) {
                equipos = usuario.getEquipos();
            }

            if (t!=null) {
                if (t.getEstado()!= null && t.getEstado() < 2) {
                    // No ha comenzado aún

                    if (t.getParticipeList().size() < t.getMaxEquipos()) {

                        if (usuario != null) {
                            for (Equipo equipo : equipos) {
                                if (equipo.getNivel() >= t.getNivelIni()
                                        && equipo.getNivel() <= t.getNivelFin()) {
                                    apto = true;
                                }

                                int estadoEquipoTorneo = getEstadoEquipoTorneo(equipo.getId(), idTemporada);
                                if (estadoEquipoTorneo == 0) {
                                    pendiente = true;
                                } else if (estadoEquipoTorneo == 1) {
                                    apuntado = true;
                                }
                            }

                            if (!apto) {
                                retorno = TEMPORADA_NO_APTO;
                            } else {
                                if (apuntado) {
                                    retorno = TEMPORADA_INSCRITO;
                                } else {
                                    if (pendiente) {
                                        retorno = TEMPORADA_PENDIENTE;
                                    } else {
                                        retorno = TEMPORADA_LIBRE;
                                    }
                                }
                            }
                        } else {
                            retorno = TEMPORADA_LIBRE;
                        }
                    } else {
                        int estadoUsuarioTorneo = getEstadoUsuarioTorneo(t.getId());
                        if (estadoUsuarioTorneo == 0) {
                            retorno = TEMPORADA_PENDIENTE;
                        } else if (estadoUsuarioTorneo == 1) {
                            retorno = TEMPORADA_INSCRITO;
                        } else {
                            retorno = TEMPORADA_COMPLETA;
                        }
                    }
                } else {
                    if (usuario != null) {
                        for (Equipo equipo : equipos) {
                            if (equipo.getNivel() >= t.getNivelIni()
                                    && equipo.getNivel() <= t.getNivelFin()) {
                                apto = true;
                            }

                            int estadoEquipoTorneo = getEstadoEquipoTorneo(equipo.getId(), idTemporada);
                            if (estadoEquipoTorneo == 0) {
                                pendiente = true;
                            } else if (estadoEquipoTorneo == 1) {
                                apuntado = true;
                            }
                        }

                        if (apuntado) {
                            retorno = TEMPORADA_PARTICIPANDO;
                        } else {
                            retorno = TEMPORADA_COMENZADA;
                        }
                    } else {
                        retorno = TEMPORADA_COMPLETA;
                    }
                }
            }
        } catch (NoResultException nre) {
            log.error("1", nre);
        } catch (Exception e) {
            log.error("2", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return retorno;
    }

    public String listaEquiposPendientes() {
        String retorno = SUCCESS;

        log.debug("retorno: " + retorno);

        return retorno;
    }

    public List<Equipo> getListaEquipos() {
        return getUsuarioLogado().getEquipos();
    }

    private int getEstadoUsuarioTorneo(int idTemporada) {
        int retorno = -1;

        try {
            Usuario usuario = getUsuarioLogado();

            if (usuario != null) {
                List<Equipo> equipos = usuario.getEquipos();
                for (Equipo equipo : equipos) {
                    int estadoEquipoTorneo = getEstadoEquipoTorneo(equipo.getId(), idTemporada);
                    if (estadoEquipoTorneo <= 1) {
                        retorno = estadoEquipoTorneo;
                    }
                }
            }
        } catch (Exception e) {
            log.error(e);
        }

        return retorno;
    }

    private int getEstadoEquipoTorneo(int idEquipo, int idTemporada) {
        int retorno = -1;

        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager(); // checked
            Query q = em.createNamedQuery("Participe.findByEquipoIdTemporadaId");
            q.setParameter("idEquipo", idEquipo);
            q.setParameter("idTemporada", idTemporada);

            if (q.getResultList().size()>0) {
                // No hay registros
                Participe p = ((List<Participe>)q.getResultList()).get(0);
                retorno = p.getEstado();
            }
        } catch (NoResultException nre) {
            log.error("1", nre);
        } catch (Exception e) {
            log.error("2", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return retorno;
    }







    public String getLetras() {
        return letras;
    }

    public void setLetras(String letras) {
        this.letras = letras;
    }

    public List<Torneo> getDatos() {
        return datos;
    }

    public void setDatos(List<Torneo> resultadoBusqueda) {
        this.datos = resultadoBusqueda;
    }

    public int getPagina() {
        return pagina;
    }

    public void setPagina(int pagina) {
        this.pagina = pagina;
    }

    public int getCuantos() {
        return cuantos;
    }

    public void setCuantos(int cuantos) {
        this.cuantos = cuantos;
    }

    public InfoCabeceraXHR getCabecera() {
        return cabecera;
    }

    public void setCabecera(InfoCabeceraXHR cabecera) {
        this.cabecera = cabecera;
    }

    public String getModificador_historico() {
        return modificador_historico;
    }

    public void setModificador_historico(String modificador_historico) {
        this.modificador_historico = modificador_historico;
    }

    public String getModificador_media() {
        return modificador_media;
    }

    public void setModificador_media(String modificador_media) {
        this.modificador_media = modificador_media;
    }

    public String getModificador_nivel() {
        return modificador_nivel;
    }

    public void setModificador_nivel(String modificador_nivel) {
        this.modificador_nivel = modificador_nivel;
    }

    public String getModificador_posicion() {
        return modificador_posicion;
    }

    public void setModificador_posicion(String modificador_posicion) {
        this.modificador_posicion = modificador_posicion;
    }

    public String getNumero_historico() {
        return numero_historico;
    }

    public void setNumero_historico(String numero_historico) {
        this.numero_historico = numero_historico;
    }

    public String getNumero_media() {
        return numero_media;
    }

    public void setNumero_media(String numero_media) {
        this.numero_media = numero_media;
    }

    public String getNumero_nivel() {
        return numero_nivel;
    }

    public void setNumero_nivel(String numero_nivel) {
        this.numero_nivel = numero_nivel;
    }

    public String getNumero_posicion() {
        return numero_posicion;
    }

    public void setNumero_posicion(String numero_posicion) {
        this.numero_posicion = numero_posicion;
    }

    public String getCadena() {
        return cadena;
    }

    public void setCadena(String cadena) {
        this.cadena = cadena;
    }

    public String getContrasena() {
        return contrasena;
    }

    public void setContrasena(String contrasena) {
        this.contrasena = contrasena;
    }

    public String getEquipo() {
        return equipo;
    }

    public void setEquipo(String equipo) {
        this.equipo = equipo;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public List<Participe> getTorneosUsuario() {
        return torneosUsuario;
    }

    public void setTorneosUsuario(List<Participe> torneosUsuario) {
        this.torneosUsuario = torneosUsuario;
    }

    public List<Equipo> getListaEquiposManager() {
        return listaEquiposManager;
    }

    public void setListaEquiposManager(List<Equipo> listaEquiposManager) {
        this.listaEquiposManager = listaEquiposManager;
    }

    public List<Torneo> getTorneosSugeridos() {
        return torneosSugeridos;
    }

    public void setTorneosSugeridos(List<Torneo> torneosSugeridos) {
        this.torneosSugeridos = torneosSugeridos;
    }

    public List<Torneo> getTorneosPropios() {
        return torneosPropios;
    }

    public void setTorneosPropios(List<Torneo> torneosPropios) {
        this.torneosPropios = torneosPropios;
    }

    public int getMostrarPropios() {
        return mostrarPropios;
    }

    public void setMostrarPropios(int mostrarPropios) {
        this.mostrarPropios = mostrarPropios;
    }

}
